diff --git a/user_guide/changelog.html b/user_guide/changelog.html
index 94e41a8..7a59eaf 100644
--- a/user_guide/changelog.html
+++ b/user_guide/changelog.html
@@ -449,7 +449,7 @@
 	<li>Fixed a bug (#2732) in the SQLite driver for PHP 4.</li>
 	<li>Fixed a bug (#2754) in Pagination to scan for non-positive num_links.</li>
 	<li>Fixed a bug (#2762) in the <a href="./libraries/sessions.html">Session library</a> where user agent matching would fail on user agents ending with a space. </li>
-	<li>Fixed a bug (#2784) $field_names[] vs $Ffield_names[] in postgre and sqlite drivers.</li>
+	<li>Fixed a bug (#2784) $field_names[] vs $Ffield_names[] in postgres and sqlite drivers.</li>
 	<li>Fixed a bug (#2810) in the typography helper causing extraneous paragraph tags when string contains tags.</li>
 	<li>Fixed a bug (#2849) where arguments passed to a subfolder controller method would be incorrectly shifted, dropping the 3rd segment value.</li>
 	<li>Fixed a bug (#2858) which referenced a wrong variable in the Image class.</li>
@@ -545,7 +545,7 @@
 	<li>Fixed a bug in result_array() that was returning an empty array when no result is produced.</li>
 	<li>Fixed a bug in the redirect function of the <a href="./helpers/url_helper.html">url helper</a>. </li>
 	<li>Fixed an undefined variable in Loader </li>
-	<li>Fixed a version bug in the Postgre driver </li>
+	<li>Fixed a version bug in the Postgres driver </li>
 	<li>Fixed a bug in the textarea function of the form helper for use with strings</li>
 	<li>Fixed doc typos. </li>
 </ul>
@@ -683,7 +683,7 @@
 <li>Added support for % character in URL.</li>
 <li>Added the ability to supply full URLs using the <a href="./helpers/url_helper.html">anchor()</a> helper function.</li>
 <li>Added mode parameter to <a href="./helpers/file_helper.html">file_write()</a> helper.</li>
-<li>Added support for changing the port number in the <a href="./database/configuration.html">Postgre driver</a>.</li>
+<li>Added support for changing the port number in the <a href="./database/configuration.html">Postgres driver</a>.</li>
 <li>Moved the list of "allowed URI characters" out of the Router class and into the config file.</li>
 <li>Moved the MIME type array out of the Upload class and into its own file in the applications/config/ folder.</li>
 <li>Updated the Upload class to allow the upload field name to be set when calling <a href="./libraries/file_uploading.html">do_upload()</a>.</li>
@@ -694,10 +694,10 @@
 <li>Updated the SQLite Driver to check for object support before attempting to return results as objects.  If unsupported it returns an array.</li>
 <li>Updated the Models loader function to allow multiple loads of the same model.</li>
 <li>Updated the MS SQL driver so that single quotes are escaped.</li>
-<li>Updated the Postgre and ODBC drivers for better compatibility.</li>
+<li>Updated the Postgres and ODBC drivers for better compatibility.</li>
 <li>Removed a strtolower() call that was changing URL segments to lower case.</li>
 <li>Removed some references that were interfering with PHP 4.4.1 compatibility.</li>
-<li>Removed backticks from Postgre class since these are not needed.</li>
+<li>Removed backticks from Postgres class since these are not needed.</li>
 <li>Renamed <dfn>display()</dfn> to <dfn>_display()</dfn> in the Output class to make it clear that it's a private function.</li>
 <li>Deprecated the hash() function due to a naming conflict with a native PHP function with the same name.  Please use <kbd>dohash()</kbd> instead.</li>
 <li>Fixed an bug that was preventing the input class from unsetting GET variables.</li>
@@ -790,7 +790,7 @@
 
 <ul>
 <li>Added support for <a href="models.html">Models</a>.</li>
-<li>Redesigned the database libraries to support additional RDBMs (Postgre, MySQLi, etc.).</li>
+<li>Redesigned the database libraries to support additional RDBMs (Postgres, MySQLi, etc.).</li>
 <li>Redesigned the <a href="./database/active_record.html">Active Record class</a> to enable more varied types of queries with simpler syntax, and advanced features like JOINs.</li>
 <li>Added a feature to the database class that lets you run <a href="./database/call_function.html">custom function calls</a>.</li>
 <li>Added support for <a href="controllers.html">private functions</a> in your controllers.  Any controller function name that starts with an underscore will not be served by a URI request.</li>
diff --git a/user_guide/database/configuration.html b/user_guide/database/configuration.html
index 2c16f36..26bbe75 100644
--- a/user_guide/database/configuration.html
+++ b/user_guide/database/configuration.html
@@ -121,7 +121,7 @@
 <li><strong>username</strong> - The username used to connect to the database.</li>
 <li><strong>password</strong> - The password used to connect to the database.</li>
 <li><strong>database</strong> - The name of the database you want to connect to.</li>
-<li><strong>dbdriver</strong> - The database type. ie: mysql, postgre, odcc, etc. Must be specified in lower case.</li>
+<li><strong>dbdriver</strong> - The database type. ie: mysql, postgres, odcc, etc. Must be specified in lower case.</li>
 <li><strong>dbprefix</strong> - An optional table prefix which will added to the table name when running <a href="active_record.html">Active Record</a> queries.  This permits multiple CodeIgniter installations to share one database.</li>
 <li><strong>pconnect</strong> - TRUE/FALSE (boolean) - Whether to use a persistent connection.</li>
 <li><strong>db_debug</strong> - TRUE/FALSE (boolean) - Whether database errors should be displayed.</li>
@@ -129,10 +129,10 @@
 <li><strong>cachedir</strong> - The absolute server path to your database query cache directory.</li>
 <li><strong>char_set</strong> - The character set used in communicating with the database.</li>
 <li><strong>dbcollat</strong> - The character collation used in communicating with the database.</li>
-<li><strong>port</strong> - The database port number.  Currently only used with the Postgre driver. To use this value you have to add a line to the database config array.<code>$db['default']['port'] =  5432;</code></li>
+<li><strong>port</strong> - The database port number.  Currently only used with the Postgres driver. To use this value you have to add a line to the database config array.<code>$db['default']['port'] =  5432;</code></li>
 </ul>
 
-<p class="important"><strong>Note:</strong> Depending on what database platform you are using (MySQL, Postgre, etc.)
+<p class="important"><strong>Note:</strong> Depending on what database platform you are using (MySQL, Postgres, etc.)
 not all values will be needed.  For example, when using SQLite you will not need to supply a username or password, and
 the database name will be the path to your database file. The information above assumes you are using MySQL.</p>
 
diff --git a/user_guide/database/helpers.html b/user_guide/database/helpers.html
index ac6ea11..0647e2a 100644
--- a/user_guide/database/helpers.html
+++ b/user_guide/database/helpers.html
@@ -80,7 +80,7 @@
 
 
 <h2>$this->db->platform()</h2>
-<p>Outputs the database platform you are running (MySQL, MS SQL, Postgre, etc...):</p>
+<p>Outputs the database platform you are running (MySQL, MS SQL, Postgres, etc...):</p>
 <code>echo $this->db->platform();</code>
 
 
diff --git a/user_guide/general/requirements.html b/user_guide/general/requirements.html
index a655197..742cd19 100644
--- a/user_guide/general/requirements.html
+++ b/user_guide/general/requirements.html
@@ -59,7 +59,7 @@
 
 <ul>
 	<li><a href="http://www.php.net/">PHP</a> version 4.3.2 or newer.</li>
-	<li>A Database is required for most web application programming. Current supported databases are MySQL (4.1+), MySQLi, MS SQL, Postgre, Oracle, SQLite, and ODBC.</li>
+	<li>A Database is required for most web application programming. Current supported databases are MySQL (4.1+), MySQLi, MS SQL, Postgres, Oracle, SQLite, and ODBC.</li>
 </ul>
 
 
